home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / lib-old / ni.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  16KB  |  497 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''New import scheme with package support.
  5.  
  6. Quick Reference
  7. ---------------
  8.  
  9. - To enable package support, execute "import ni" before importing any
  10.   packages.  Importing this module automatically installs the relevant
  11.   import hooks.
  12.  
  13. - To create a package named spam containing sub-modules ham, bacon and
  14.   eggs, create a directory spam somewhere on Python\'s module search
  15.   path (i.e. spam\'s parent directory must be one of the directories in
  16.   sys.path or $PYTHONPATH); then create files ham.py, bacon.py and
  17.   eggs.py inside spam.
  18.  
  19. - To import module ham from package spam and use function hamneggs()
  20.   from that module, you can either do
  21.  
  22.     import spam.ham             # *not* "import spam" !!!
  23.     spam.ham.hamneggs()
  24.  
  25.   or
  26.  
  27.     from spam import ham
  28.     ham.hamneggs()
  29.  
  30.   or
  31.  
  32.     from spam.ham import hamneggs
  33.     hamneggs()
  34.  
  35. - Importing just "spam" does not do what you expect: it creates an
  36.   empty package named spam if one does not already exist, but it does
  37.   not import spam\'s submodules.  The only submodule that is guaranteed
  38.   to be imported is spam.__init__, if it exists.  Note that
  39.   spam.__init__ is a submodule of package spam.  It can reference to
  40.   spam\'s namespace via the \'__.\' prefix, for instance
  41.  
  42.     __.spam_inited = 1          # Set a package-level variable
  43.  
  44.  
  45.  
  46. Theory of Operation
  47. -------------------
  48.  
  49. A Package is a module that can contain other modules.  Packages can be
  50. nested.  Package introduce dotted names for modules, like P.Q.M, which
  51. could correspond to a file P/Q/M.py found somewhere on sys.path.  It
  52. is possible to import a package itself, though this makes little sense
  53. unless the package contains a module called __init__.
  54.  
  55. A package has two variables that control the namespace used for
  56. packages and modules, both initialized to sensible defaults the first
  57. time the package is referenced.
  58.  
  59. (1) A package\'s *module search path*, contained in the per-package
  60. variable __path__, defines a list of *directories* where submodules or
  61. subpackages of the package are searched.  It is initialized to the
  62. directory containing the package.  Setting this variable to None makes
  63. the module search path default to sys.path (this is not quite the same
  64. as setting it to sys.path, since the latter won\'t track later
  65. assignments to sys.path).
  66.  
  67. (2) A package\'s *import domain*, contained in the per-package variable
  68. __domain__, defines a list of *packages* that are searched (using
  69. their respective module search paths) to satisfy imports.  It is
  70. initialized to the list consisting of the package itself, its parent
  71. package, its parent\'s parent, and so on, ending with the root package
  72. (the nameless package containing all top-level packages and modules,
  73. whose module search path is None, implying sys.path).
  74.  
  75. The default domain implements a search algorithm called "expanding
  76. search".  An alternative search algorithm called "explicit search"
  77. fixes the import search path to contain only the root package,
  78. requiring the modules in the package to name all imported modules by
  79. their full name.  The convention of using \'__\' to refer to the current
  80. package (both as a per-module variable and in module names) can be
  81. used by packages using explicit search to refer to modules in the same
  82. package; this combination is known as "explicit-relative search".
  83.  
  84. The PackageImporter and PackageLoader classes together implement the
  85. following policies:
  86.  
  87. - There is a root package, whose name is \'\'.  It cannot be imported
  88.   directly but may be referenced, e.g. by using \'__\' from a top-level
  89.   module.
  90.  
  91. - In each module or package, the variable \'__\' contains a reference to
  92.   the parent package; in the root package, \'__\' points to itself.
  93.  
  94. - In the name for imported modules (e.g. M in "import M" or "from M
  95.   import ..."), a leading \'__\' refers to the current package (i.e.
  96.   the package containing the current module); leading \'__.__\' and so
  97.   on refer to the current package\'s parent, and so on.  The use of
  98.   \'__\' elsewhere in the module name is not supported.
  99.  
  100. - Modules are searched using the "expanding search" algorithm by
  101.   virtue of the default value for __domain__.
  102.  
  103. - If A.B.C is imported, A is searched using __domain__; then
  104.   subpackage B is searched in A using its __path__, and so on.
  105.  
  106. - Built-in modules have priority: even if a file sys.py exists in a
  107.   package, "import sys" imports the built-in sys module.
  108.  
  109. - The same holds for frozen modules, for better or for worse.
  110.  
  111. - Submodules and subpackages are not automatically loaded when their
  112.   parent packages is loaded.
  113.  
  114. - The construct "from package import *" is illegal.  (It can still be
  115.   used to import names from a module.)
  116.  
  117. - When "from package import module1, module2, ..." is used, those
  118.     modules are explicitly loaded.
  119.  
  120. - When a package is loaded, if it has a submodule __init__, that
  121.   module is loaded.  This is the place where required submodules can
  122.   be loaded, the __path__ variable extended, etc.  The __init__ module
  123.   is loaded even if the package was loaded only in order to create a
  124.   stub for a sub-package: if "import P.Q.R" is the first reference to
  125.   P, and P has a submodule __init__, P.__init__ is loaded before P.Q
  126.   is even searched.
  127.  
  128. Caveats:
  129.  
  130. - It is possible to import a package that has no __init__ submodule;
  131.   this is not particularly useful but there may be useful applications
  132.   for it (e.g. to manipulate its search paths from the outside!).
  133.  
  134. - There are no special provisions for os.chdir().  If you plan to use
  135.   os.chdir() before you have imported all your modules, it is better
  136.   not to have relative pathnames in sys.path.  (This could actually be
  137.   fixed by changing the implementation of path_join() in the hook to
  138.   absolutize paths.)
  139.  
  140. - Packages and modules are introduced in sys.modules as soon as their
  141.   loading is started.  When the loading is terminated by an exception,
  142.   the sys.modules entries remain around.
  143.  
  144. - There are no special measures to support mutually recursive modules,
  145.   but it will work under the same conditions where it works in the
  146.   flat module space system.
  147.  
  148. - Sometimes dummy entries (whose value is None) are entered in
  149.   sys.modules, to indicate that a particular module does not exist --
  150.   this is done to speed up the expanding search algorithm when a
  151.   module residing at a higher level is repeatedly imported (Python
  152.   promises that importing a previously imported module is cheap!)
  153.  
  154. - Although dynamically loaded extensions are allowed inside packages,
  155.   the current implementation (hardcoded in the interpreter) of their
  156.   initialization may cause problems if an extension invokes the
  157.   interpreter during its initialization.
  158.  
  159. - reload() may find another version of the module only if it occurs on
  160.   the package search path.  Thus, it keeps the connection to the
  161.   package to which the module belongs, but may find a different file.
  162.  
  163. XXX Need to have an explicit name for \'\', e.g. \'__root__\'.
  164.  
  165. '''
  166. import imp
  167. import sys
  168. import __builtin__
  169. import ihooks
  170. from ihooks import ModuleLoader, ModuleImporter
  171.  
  172. class PackageLoader(ModuleLoader):
  173.     """A subclass of ModuleLoader with package support.
  174.  
  175.     find_module_in_dir() will succeed if there's a subdirectory with
  176.     the given name; load_module() will create a stub for a package and
  177.     load its __init__ module if it exists.
  178.  
  179.     """
  180.     
  181.     def find_module_in_dir(self, name, dir):
  182.         if dir is not None:
  183.             dirname = self.hooks.path_join(dir, name)
  184.             if self.hooks.path_isdir(dirname):
  185.                 return (None, dirname, ('', '', 'PACKAGE'))
  186.             
  187.         
  188.         return ModuleLoader.find_module_in_dir(self, name, dir)
  189.  
  190.     
  191.     def load_module(self, name, stuff):
  192.         (file, filename, info) = stuff
  193.         (suff, mode, type) = info
  194.         if type == 'PACKAGE':
  195.             return self.load_package(name, stuff)
  196.         
  197.         if sys.modules.has_key(name):
  198.             m = sys.modules[name]
  199.         else:
  200.             sys.modules[name] = m = imp.new_module(name)
  201.         self.set_parent(m)
  202.         if type == imp.C_EXTENSION and '.' in name:
  203.             return self.load_dynamic(name, stuff)
  204.         else:
  205.             return ModuleLoader.load_module(self, name, stuff)
  206.  
  207.     
  208.     def load_dynamic(self, name, stuff):
  209.         (suff, mode, type) = (file, filename)
  210.         i = name.rfind('.')
  211.         tail = name[i + 1:]
  212.         if sys.modules.has_key(tail):
  213.             save = sys.modules[tail]
  214.         else:
  215.             save = None
  216.         sys.modules[tail] = imp.new_module(name)
  217.         
  218.         try:
  219.             m = imp.load_dynamic(tail, filename, file)
  220.         finally:
  221.             if save:
  222.                 sys.modules[tail] = save
  223.             else:
  224.                 del sys.modules[tail]
  225.  
  226.         sys.modules[name] = m
  227.         return m
  228.  
  229.     
  230.     def load_package(self, name, stuff):
  231.         (file, filename, info) = stuff
  232.         if sys.modules.has_key(name):
  233.             package = sys.modules[name]
  234.         else:
  235.             sys.modules[name] = package = imp.new_module(name)
  236.         package.__path__ = [
  237.             filename]
  238.         self.init_package(package)
  239.         return package
  240.  
  241.     
  242.     def init_package(self, package):
  243.         self.set_parent(package)
  244.         self.set_domain(package)
  245.         self.call_init_module(package)
  246.  
  247.     
  248.     def set_parent(self, m):
  249.         name = m.__name__
  250.         if '.' in name:
  251.             name = name[:name.rfind('.')]
  252.         else:
  253.             name = ''
  254.         m.__ = sys.modules[name]
  255.  
  256.     
  257.     def set_domain(self, package):
  258.         name = package.__name__
  259.         package.__domain__ = domain = [
  260.             name]
  261.         while '.' in name:
  262.             name = name[:name.rfind('.')]
  263.             domain.append(name)
  264.         if name:
  265.             domain.append('')
  266.         
  267.  
  268.     
  269.     def call_init_module(self, package):
  270.         stuff = self.find_module('__init__', package.__path__)
  271.         if stuff:
  272.             m = self.load_module(package.__name__ + '.__init__', stuff)
  273.             package.__init__ = m
  274.         
  275.  
  276.  
  277.  
  278. class PackageImporter(ModuleImporter):
  279.     """Importer that understands packages and '__'."""
  280.     
  281.     def __init__(self, loader = None, verbose = 0):
  282.         if not loader:
  283.             pass
  284.         ModuleImporter.__init__(self, PackageLoader(None, verbose), verbose)
  285.  
  286.     
  287.     def import_module(self, name, globals = { }, locals = { }, fromlist = []):
  288.         if globals.has_key('__'):
  289.             package = globals['__']
  290.         else:
  291.             package = sys.modules['']
  292.         if name[:3] in ('__.', '__'):
  293.             p = package
  294.             name = name[3:]
  295.             while name[:3] in ('__.', '__'):
  296.                 p = p.__
  297.                 name = name[3:]
  298.             if not name:
  299.                 return self.finish(package, p, '', fromlist)
  300.             
  301.             if '.' in name:
  302.                 i = name.find('.')
  303.                 name = name[:i]
  304.                 tail = name[i:]
  305.             else:
  306.                 tail = ''
  307.             if not p.__name__ or p.__name__ + '.' + name:
  308.                 pass
  309.             mname = name
  310.             m = self.get1(mname)
  311.             return self.finish(package, m, tail, fromlist)
  312.         
  313.         if '.' in name:
  314.             i = name.find('.')
  315.             name = name[:i]
  316.             tail = name[i:]
  317.         else:
  318.             tail = ''
  319.         for pname in package.__domain__:
  320.             if not pname or pname + '.' + name:
  321.                 pass
  322.             mname = name
  323.             m = self.get0(mname)
  324.             if m:
  325.                 break
  326.                 continue
  327.         else:
  328.             raise ImportError, 'No such module %s' % name
  329.         return self.finish(m, m, tail, fromlist)
  330.  
  331.     
  332.     def finish(self, module, m, tail, fromlist):
  333.         yname = m.__name__
  334.         if tail and sys.modules.has_key(yname + tail):
  335.             yname = yname + tail
  336.             tail = ''
  337.             m = self.get1(yname)
  338.         
  339.         while tail:
  340.             i = tail.find('.', 1)
  341.             if i > 0:
  342.                 head = tail[:i]
  343.                 tail = tail[i:]
  344.             else:
  345.                 head = tail
  346.                 tail = ''
  347.             yname = yname + head
  348.             m = self.get1(yname)
  349.         if not fromlist:
  350.             return module
  351.         
  352.         if '__' in fromlist:
  353.             raise ImportError, "Can't import __ from anywhere"
  354.         
  355.         if not hasattr(m, '__path__'):
  356.             return m
  357.         
  358.         if '*' in fromlist:
  359.             raise ImportError, "Can't import * from a package"
  360.         
  361.         for f in fromlist:
  362.             if hasattr(m, f):
  363.                 continue
  364.             
  365.             fname = yname + '.' + f
  366.             self.get1(fname)
  367.         
  368.         return m
  369.  
  370.     
  371.     def get1(self, name):
  372.         m = self.get(name)
  373.         if not m:
  374.             raise ImportError, 'No module named %s' % name
  375.         
  376.         return m
  377.  
  378.     
  379.     def get0(self, name):
  380.         m = self.get(name)
  381.         if not m:
  382.             sys.modules[name] = None
  383.         
  384.         return m
  385.  
  386.     
  387.     def get(self, name):
  388.         if sys.modules.has_key(name):
  389.             return sys.modules[name]
  390.         
  391.         if '.' in name:
  392.             i = name.rfind('.')
  393.             head = name[:i]
  394.             tail = name[i + 1:]
  395.         else:
  396.             head = ''
  397.             tail = name
  398.         path = sys.modules[head].__path__
  399.         stuff = self.loader.find_module(tail, path)
  400.         if not stuff:
  401.             return None
  402.         
  403.         sys.modules[name] = m = self.loader.load_module(name, stuff)
  404.         if head:
  405.             setattr(sys.modules[head], tail, m)
  406.         
  407.         return m
  408.  
  409.     
  410.     def reload(self, module):
  411.         name = module.__name__
  412.         if '.' in name:
  413.             i = name.rfind('.')
  414.             head = name[:i]
  415.             tail = name[i + 1:]
  416.             path = sys.modules[head].__path__
  417.         else:
  418.             tail = name
  419.             path = sys.modules[''].__path__
  420.         stuff = self.loader.find_module(tail, path)
  421.         if not stuff:
  422.             raise ImportError, 'No module named %s' % name
  423.         
  424.         return self.loader.load_module(name, stuff)
  425.  
  426.     
  427.     def unload(self, module):
  428.         if hasattr(module, '__path__'):
  429.             raise ImportError, "don't know how to unload packages yet"
  430.         
  431.         PackageImporter.unload(self, module)
  432.  
  433.     
  434.     def install(self):
  435.         if not sys.modules.has_key(''):
  436.             sys.modules[''] = package = imp.new_module('')
  437.             package.__path__ = None
  438.             self.loader.init_package(package)
  439.             for m in sys.modules.values():
  440.                 if not m:
  441.                     continue
  442.                 
  443.                 if not hasattr(m, '__'):
  444.                     self.loader.set_parent(m)
  445.                     continue
  446.             
  447.         
  448.         ModuleImporter.install(self)
  449.  
  450.  
  451.  
  452. def install(v = 0):
  453.     ihooks.install(PackageImporter(None, v))
  454.  
  455.  
  456. def uninstall():
  457.     ihooks.uninstall()
  458.  
  459.  
  460. def ni(v = 0):
  461.     install(v)
  462.  
  463.  
  464. def no():
  465.     uninstall()
  466.  
  467.  
  468. def test():
  469.     import pdb as pdb
  470.     
  471.     try:
  472.         testproper()
  473.     except:
  474.         (sys.last_type, sys.last_value, sys.last_traceback) = sys.exc_info()
  475.         print 
  476.         print sys.last_type, ':', sys.last_value
  477.         print 
  478.         pdb.pm()
  479.  
  480.  
  481.  
  482. def testproper():
  483.     install(1)
  484.     
  485.     try:
  486.         import mactest as mactest
  487.         print dir(mactest)
  488.         raw_input('OK?')
  489.     finally:
  490.         uninstall()
  491.  
  492.  
  493. if __name__ == '__main__':
  494.     test()
  495. else:
  496.     install()
  497.